查看原文
其他

深入LINQ | 动态构建LINQ表达式

DotNet 2021-12-16

The following article is from 精致码农 Author liamwang

LINQ 是 Language Integrated Query(语言集成查询)的缩写,是我最喜欢的 .NET 和 C# 技术之一。使用 LINQ,开发者可以直接在强类型代码中编写查询。LINQ 提供了一种标准的语言和语法,使不同的数据源的查询编码方法一致。


一、基础


考虑如下这个 LINQ 查询(你可以把它粘贴到一个控制台应用程序中运行)。

using System;  
using System.Linq;  
  
public class Program  
{  
   public static void Main()  
   {  
      var someNumbers = new int[]{4815162342};  
      var query =  
         from num in someNumbers  
            where num > 10  
            orderby num descending  
            select num.ToString();  
      Console.WriteLine(string.Join('-', query.ToArray()));  
      // 42-23-16-15  
   }  
}

因为 someNumbers 是一个 IEnumerable<int>,该查询是被 LINQ to Objects 解析的。同样的查询语法可用于像 Entity Framework Core 这样的工具,生成针对关系型数据库运行的 T-SQL。LINQ 可以使用两种语法来编写:查询语法(如上所示)和(扩展)方法语法。这两种语法在语义上是相同的,你使用哪一种语法取决于你的偏好。上面同样的查询可以用方法语法写成这样:

var secondQuery = someNumbers.Where(n => n > 10)  
    .OrderByDescending(n => n)  
    .Select(n => n.ToString());

每个 LINQ 查询都有三个阶段:

  1. 设置一个数据源,称为提供者(provider),供查询时使用。例如,到目前为止的代码使用了内置的 LINQ to Objects 提供者。你的 EF Core 项目使用的是 EF Core 提供者,它映射到你的数据库。

  2. 查询被定义并转变成一个表达式树(expression tree),我将在稍后介绍。

  3. 查询被执行,数据被返回。

第 3 步很重要,因为 LINQ 使用了所谓的延迟执行(deferred execution)。在上面的例子中,secondQuery 定义了一个表达式树,但还没有返回任何数据。事实上,在你开始迭代数据之前,实际上什么都没有发生。这很重要,因为它允许提供者通过只提供所要求的数据。例如,假设你想用 secondQuery 找到一个特定的字符串,所以你做了这样的事情:

var found = false;  
foreach(var item in secondQuery.AsEnumerable())  
{  
    if (item == "23")  
    {  
        found = true;  
        break;  
    }  
}

一个提供者通过枚举器(enumerator)访问,这样它就可以一次输入一个元素的数据。如果你在第三次迭代时得到了想要的值,可能实际上只有三条数据从数据库中返回。另一方面,当你使用 .ToList() 扩展方法时,所有的数据都会立即被取出并填充到列表中。

二、难题

我作为我们公司的 .NET 项目经理,我经常与客户交谈,了解他们的需求。最近,我与一位客户进行了讨论,他想在他们的网站上使用第三方控件来建立业务规则。更具体地说,业务规则是“谓词”(predicates,译注:也可以翻译成判断语句)或一组条件,可解析为 truefalse

该工具可以用 JSON 或 SQL 格式生成规则。SQL 很香,可以持久化到给数据库,但他们的要求是将“谓词”应用于内存对象,作为服务器上的一个过滤器。他们正在考虑使用一种工具,将 SQL 翻译成表达式(其实就是动态生成 LINQ)。

我建议使用 JSON 格式,因为它可以被解析成 LINQ 表达式,针对内存中的对象运行,或者很容易应用到 Entity Framework Core 集合,相对 SQL 数据库是更好的选择。我只要处理工具产生的 JSON:

{  
  "condition""and",  
  "rules": [  
    {  
      "label""Category",  
      "field""Category",  
      "operator""in",  
      "type""string",  
      "value": ["Clothing"]  
    },  
    {  
      "condition""or",  
      "rules": [  
        {  
          "label""TransactionType",  
          "field""TransactionType",  
          "operator""equal",  
          "type""boolean",  
          "value""income"  
        },  
        {  
          "label""PaymentMode",  
          "field""PaymentMode",  
          "operator""equal",  
          "type""string",  
          "value""Cash"  
        }  
      ]  
    },  
    {  
      "label""Amount",  
      "field""Amount",  
      "operator""equal",  
      "type""number",  
      "value"10  
    }  
  ]  
}

结构很简单:有一个 ANDOR 条件,包含一组规则,要么是比较,要么是嵌套条件。我的目标有两个:学习更多关于 LINQ 表达式的知识,以便更好地了解 EF Core 和相关技术;提供一个简单的例子,说明如何在不依赖第三方工具的情况下使用 JSON。

三、动态表达式

我创建了一个简单的控制台应用程序来测试我的假设,即解析 JSON 信息直接生成 LINQ 查询。

https://github.com/JeremyLikness/ExpressionGenerator

译注:建议参照此 GitHub 源代码阅读本文,方便理解。

在本文的第一部分,将启动项目设置为 ExpressionGenerator。如果你从命令行运行它,请确保 rules.json 在你的当前目录中。我将样本 JSON 嵌入为 rules.json。使用 System.Text.Json 来解析文件,就是这么简单:

var jsonStr = File.ReadAllText("rules.json");  
var jsonDocument = JsonDocument.Parse(jsonStr);

然后我创建了一个 JsonExpressionParser 来解析 JSON 并创建一个表达式树。因为动态表达式是一个谓词,所以表达式树是由二元表达式 BinaryExpression 的实例构成的,这些实例计算一个左表达式和一个右表达式。这个计算可能是一个逻辑门(ANDOR),或一个比较(equalgreaterThan),或一个方法调用。对于 In 的情况,即我们想让属性 Category 出现在一个列表中,我使用 Contains。从概念上讲,引用的 JSON 看起来像这样:

 /-----------AND-----------\  
                         |                         |  
                      /-AND-\                      |  
Category IN ['Clothing']   Amount eq 10.0        /-OR-\  
                        TransactionType EQ 'income'  PaymentMode EQ 'Cash'

注意,每个节点都是二元的。让我们开始解析吧!

四、引入 Transaction

注意,这不是 System.Transaction(这里的 Transaction 不是指事务,而是指交易)。这是示例项目中使用的一个自定义类。我没有在供应商的网站上花很多时间,所以我根据规则猜测实体可能的样子。我想出了这个:

public class Transaction  
{  
  public int Id { getset; }  
  public string Category { getset; }  
  public string TransactionType { getset; }  
  public string PaymentMode { getset; }  
  public decimal Amount { getset; }  
}

我还添加了一些额外的方法,以使其易于生成随机实例。你可以自己在 GitHub 代码中看到这些。

五、参数表达式

主要方法返回一个谓词(predicate)函数。下面是该方法开始部分的代码:

public Func<T, bool> ParsePredicateOf<T>(JsonDocument doc)  
{  
   var itemExpression = Expression.Parameter(typeof(T));  
   var conditions = ParseTree<T>(doc.RootElement, itemExpression);  
}

第一步是创建谓词参数。谓词可以传递给 Where 子句,如果我们自己写的话,它看起来就像这样:

var query = ListOfThings.Where(t => t.Id > 2);

t => 是一个参数,代表列表中一个条目的类型。因此,我们为该类型创建一个参数。然后我们递归地遍历 JSON 节点来建立树。

六、逻辑表达式

解析器的开头看起来像这样:

private Expression ParseTree<T>(  
    JsonElement condition,  
    ParameterExpression parm)  
    {  
        Expression left = null;  
        var gate = condition.GetProperty(nameof(condition)).GetString();  
  
        JsonElement rules = condition.GetProperty(nameof(rules));  
  
        Binder binder = gate == And ? (Binder)Expression.And : Expression.Or;  
  
        Expression bind(Expression left, Expression right) =>  
            left == null ? right : binder(left, right);

gate 变量是条件,即“and”或“or”。规则语句得到一个节点,是相关规则的列表。我们正在跟踪表达式的左边和右边。Binder 签名是二元表达式的简写,定义如下:

private delegate Expression Binder(Expression left, Expression right);

binder 变量简单地设置了顶层表达式:Expression.AndExpression.Or。两者都使用左边和右边表达式来计算。bind 函数更有趣一点。当我们遍历树时,我们需要建立各种节点。如果我们还没有创建一个表达式(leftnull),我们就从创建的第一个表达式开始。如果我们有一个现有的表达式,我们就用这个表达式来合并两边的内容。现在,leftnull,然后我们开始列举属于这个条件的规则:

foreach (var rule in rules.EnumerateArray())

七、属性表达式

第一条规则是一个相等规则,所以我现在跳过条件部分。大致情况是下面这样的:

string @operator = rule.GetProperty(nameof(@operator)).GetString();  
string type = rule.GetProperty(nameof(type)).GetString();  
string field = rule.GetProperty(nameof(field)).GetString();  
JsonElement value = rule.GetProperty(nameof(value));  
var property = Expression.Property(parm, field);

首先,我们得到运算符(in)、类型(string)、字段(Category)和值(一个以Clothing为唯一元素的数组)。注意对 Expression.Property 的调用。这个规则的 LINQ 看起来是这样的:

var filter = new List<string> { "Clothing" };  
Transactions.Where(t => filter.Contains(t.Category));

该属性是 t.Category,所以我们根据父属性(t)和字段名来创建它。

八、常量和调用表达式

接下来,我们需要建立对 Contains 的调用。为了简化,我在这里创建了一个对该方法的引用:

private readonly MethodInfo MethodContains = typeof(Enumerable).GetMethods(  
  BindingFlags.Static | BindingFlags.Public)  
  .Single(m => m.Name == nameof(Enumerable.Contains)  
      && m.GetParameters().Length == 2);

这就动态提取了 EnumerableContains 方法,该方法需要两个参数:要使用的集合和要检查的值。接下来的逻辑看起来像这样:

if (@operator == In)  
{  
    var contains = MethodContains.MakeGenericMethod(typeof(string));  
    object val = value.EnumerateArray().Select(e => e.GetString())  
        .ToList();  
    var right = Expression.Call(  
        contains,  
        Expression.Constant(val),  
        property);  
    left = bind(left, right); 
}

首先,我们使用 Enumerable.Contains 模板来创建一个 Enumerable<string>。接下来,我们获取值的列表,把它变成一个 List<string>。最后,建立我们的调用,需要传递:

  • 要调用的方法(contains

  • 要检查的参数的值(带有 Clothing 的列表,或者 Expression.Constant(val)

  • 要对其进行检查的属性(t.Category)。

我们的表达式树已经相当深了,有参数、属性、调用和常量。记住,left 仍然是空的,所以对 bind 的调用只是将 left 设置为我们刚刚创建的调用表达式。到目前为止,看起来像这样:

Transactions.Where(t => (new List<string> { "Clothing" }).Contains(t.Category));

循环往复,下一个规则是一个嵌套条件。关键代码如下:

if (rule.TryGetProperty(nameof(condition), out JsonElement check))  
{  
    var right = ParseTree<T>(rule, parm);  
    left = bind(left, right);  
    continue;  
}

目前,left 被分配给 in 表达式。right 将被分配为解析新条件的结果。现在,我们的 binder 被设置为 Expression.And,所以当函数返回时,bind 的调用结果是这样的:

Transactions.Where(t => (new List<string> { "Clothing" }).Contains(t.Category) && <something>);

我们再来看看这里的“something”。

九、比较表达式

首先,递归调用确定了一个新的条件存在,这次是一个逻辑 OR。binder 被设置为 Expression.Or,规则开始运算。第一条规则是关于 TransactionType 的。它被设置为布尔值,但根据我的推断,它意味着用户在界面中可以选择一个值或切换到另一个值。因此,我把它实现为一个简单的字符串比较。下面是建立比较的代码:

object val = (type == StringStr || type == BooleanStr) ?  
    (object)value.GetString() : value.GetDecimal();  
var toCompare = Expression.Constant(val);  
var right = Expression.Equal(property, toCompare);  
left = bind(left, right);

该值被解析为字符串或小数(后面的规则将使用小数格式)。然后,该值被转换成一个常数,然后创建比较。注意它是通过属性比较的。现在的变量看起来像这样:

Transactions.Where(t => t.TransactionType == "income");

在这个嵌套循环中,left 仍然是空的。解析器计算了下一条规则,即 PaymentModebind 函数把它变成了这个“或”语句:

Transactions.Where(t => t.TransactionType == "income" || t.PaymentMode == "Cash");

其余的应该是不言自明的。表达式的一个很好的特点是它们可以重载 ToString() 来展现输出。下面就是我们的表达式的样子(为了方便查看,我手动进行了格式化):

(  
  (value(System.Collections.Generic.List`1[System.String]).Contains(Param_0.Category)  
      And (  
          (Param_0.TransactionType == "income")  
          Or  
          (Param_0.PaymentMode == "Cash"))  
      )  
  And  
  (Param_0.Amount == 10)  
)

它看起来不错......但我们还没有完成!

十、Lambda 表达式和编译

接下来,我创建一个 lambda 表达式。这里定义了解析后的表达式的形状,它将是一个谓词(Func<T,bool>)。最后,返回编译后的委托:

var conditions = ParseTree<T>(doc.RootElement, itemExpression);  
if (conditions.CanReduce)  
{  
    conditions = conditions.ReduceAndCheck();  
}  
var query = Expression.Lambda<Func<T, bool>>(conditions, itemExpression);  
return query.Compile();

为了测试,我生成了 1000 个 Transaction。然后我应用过滤器并迭代结果,这样我就可以手动测试条件是否满足:

var predicate = jsonExpressionParser  
                .ParsePredicateOf<Transaction>(jsonDocument);  
var transactionList = Transaction.GetList(1000);  
var filteredTransactions = transactionList.Where(predicate).ToList();  
filteredTransactions.ForEach(Console.WriteLine);

正如你所看到的,结果出来了(我平均每次运行约 70 次“命中”)。

十一、从内存到数据库

生成的委托并不只是用于对象。我们也可以用它来访问数据库。在这篇文章的其余部分,将启动项目设置为 DatabaseTest。如果你从命令行运行它,要确保 databaseRules.json 在你的当前目录中。首先,我重构了代码。还记得表达式是如何要求一个数据源的吗?在前面的例子中,我们编译了表达式,最后得到了一个对对象工作的委托。为了使用不同的数据源,我们需要在编译表达式之前将其传递给它。这允许数据源对其进行编译。如果我们传递已编译的数据源,数据库提供者将被迫从数据库中获取所有行,然后解析返回的列表。我们希望数据库来做这些工作。我把大部分代码移到一个名为 ParseExpressionOf<T> 的方法中,该方法返回 lambda。我把原来的方法重构成这样:

public Func<T, bool> ParsePredicateOf<T>(JsonDocument doc)  
{  
    var query = ParseExpressionOf<T>(doc);  
    return query.Compile();  
}

ExpressionGenerator 程序使用编译后的查询,DatabaseTest 使用原始的 lambda 表达式。它将其应用于一个本地的 SQLite 数据库,以演示 EF Core 是如何解析表达式的。在数据库中创建并插入 1000 条 Transaction 后,通过下面代码查询总数:

var count = await context.DbTransactions.CountAsync();  
Console.WriteLine($"Verified insert count: {count}.");

这会生成以下 SQL 语句:

SELECT COUNT(*)  
FROM "DbTransactions" AS "d"

谓词被解析(这次是来自 databaseRules.json 中的一组新规则)并传递给 Entity Framework Core 提供者。

var parser = new JsonExpressionParser();  
var predicate = parser.ParseExpressionOf<Transaction>(  
    JsonDocument.Parse(  
        await File.ReadAllTextAsync("databaseRules.json")));  
  var query = context.DbTransactions.Where(predicate)  
      .OrderBy(t => t.Id);  
  var results = await query.ToListAsync();

打开 Entity Framework Core 日志记录开关,我们能够检索到生成的 SQL,看到数据条目是如何被一次性获取和在数据库引擎中如何计算的。注意 PaymentMode 被检查为“Credit”而不是“Cash”。

SELECT "d"."Id""d"."Amount""d"."Category""d"."PaymentMode""d"."TransactionType"  
FROM "DbTransactions" AS "d"  
WHERE ("d"."Category" IN ('Clothing') &  
        ((("d"."TransactionType" = 'income') AND "d"."TransactionType" IS NOT NULL) |  
          (("d"."PaymentMode" = 'Credit') AND "d"."PaymentMode" IS NOT NULL))) &  
      ("d"."Amount" = '10.0')  
ORDER BY "d"."Id"

该示例应用程序还打印了一个实体,以进行抽查。

十二、总结

LINQ 表达式是一个非常强大的工具,可以过滤和转换数据。我希望这个例子有助于理解表达式树是如何构建的。当然,解析表达式树感觉有点像魔术。Entity Framework Core 是如何在表达式树上行走以产生有意义的 SQL?我正在自己探索这个问题,并得到了 ExpressionVisitor 类的帮助。我将陆续发表更多关于这个问题的文章。

- EOF -

推荐阅读  点击标题可跳转

.NET Core 消息队列的使用

.NET Worker Service 如何优雅退出

.NET Core with 微服务 - 什么是微服务


看完本文有收获?请转发分享给更多人

推荐关注「DotNet」,提升.Net技能 

点赞和在看就是最大的支持❤️

: . Video Mini Program Like ,轻点两下取消赞 Wow ,轻点两下取消在看

您可能也对以下帖子感兴趣

文章有问题?点此查看未经处理的缓存